﻿using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using Algoritmia.DataStructures.Lists;

namespace Demos.Puzzles.Polyominoes
{
    public class Casilla : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        public double Lado { get; private set; }

        private Brush _fondo;
        public Brush Fondo
        {
            get { return _fondo; }
            set { _fondo = value; NotifyPropertyChanged("Fondo"); }
        }

        public Casilla(Brush fondo, double lado)
        {
            Fondo = fondo;
            Lado = lado;
        }
    }

    public class ListaDeCasillas
    {
        public ObservableCollection<Casilla> Lista { get; private set; }

        public ListaDeCasillas(int columnas, Brush fondo, double lado)
        {
            Lista = new ObservableCollection<Casilla>();

            for (int i = 0; i < columnas; i++)
            {
                Lista.Add(new Casilla(fondo, lado));
            }
        }
    }

    public class Ficha
    {
        BrushConverter _converter = new BrushConverter();
        private List<Casilla> _casillas;
        public char Nombre { get; private set; }
        public bool Colocada { get { return _casillas.Count > 0; } }
        private Brush _color;

        public Ficha(char nombreFicha)
        {
            Nombre = nombreFicha;
            _casillas = new List<Casilla>();
            var r = new Random(Nombre);
            var a = r.Next(0x1000000);
            var colorCadena = string.Format("#{0:X6}", a);
            _color = (Brush)_converter.ConvertFromString(colorCadena);
        }

        private void Pintar()
        {
            foreach (var casilla in _casillas)
            {
                casilla.Fondo = _color;
            }
        }

        public void Colocar(Casilla casilla)
        {
            _casillas.Add(casilla);
            Pintar();
        }
    }

    class ViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        public enum Modos
        {
            Visor, EditarTablero, EditarFichas
        }

        private Modos _modo;
        private Modos Modo
        {
            get { return _modo; }
            set
            {
                _modo = value;
                CambiarModo();
                NotifyPropertyChanged("VerEditor");
            }
        }

        private ObservableCollection<ListaDeCasillas> _tablero;
        public ObservableCollection<ListaDeCasillas> Tablero
        {
            get { return _tablero; }
            set
            {
                _tablero = value;
                NotifyPropertyChanged("Tablero");
            }
        }

        private double _filas;
        public double Filas
        {
            get { return _filas; }
            set
            {
                _filas = value;
                RedimensionarTablero();
                NotifyPropertyChanged("Filas");
            }
        }

        private double _columnas;
        public double Columnas
        {
            get { return _columnas; }
            set
            {
                _columnas = value;
                RedimensionarTablero();
                NotifyPropertyChanged("Columnas");
            }
        }

        private int _filaSeleccionada;
        public int FilaSeleccionada
        {
            get { return _filaSeleccionada; } 
            set
            {
                _filaSeleccionada = value;
                SeleccionarCasilla();
            }
        }

        private int _columnaSeleccionada;
        public int ColumnaSeleccionada
        {
            get { return _columnaSeleccionada; }
            set
            {
                _columnaSeleccionada = value;
                //SeleccionarCasilla();
            }
        }

        public Visibility VerEditor { 
            get{
                if (Modo == Modos.EditarFichas || Modo == Modos.EditarTablero)
                {
                    return Visibility.Visible;
                }
                return Visibility.Hidden;
            } 
        }

        private int _n;
        private int N
        {
            get { return _n; }
            set
            {
                _n = value;
                Titulo = _n < Nombres.Count ? Nombres[_n] : Nombres[0];
                NotifyPropertyChanged("N");
                NotifyPropertyChanged("NView");
                NotifyPropertyChanged("Titulo");
            }
        }

        public string NView
        {
            get { return _n.ToString(); }
        }

        public string Titulo { get; set; }
        public ObservableCollection<string> ContenidoSelector { get; private set; }
        public ObservableCollection<string> ContenidoSelectorAlgoritmos { get; private set; }
        public bool Bloqueo { get { return Modo == Modos.EditarTablero; } }

        private int _tableroSeleccionado;
        public int TableroSeleccionado
        {
            get { return _tableroSeleccionado; }
            set
            {
                _tableroSeleccionado = value;
                CargarEjemplo();
                NotifyPropertyChanged("TableroSeleccionado");
                if (value == 0)
                {
                    Modo = Modos.EditarTablero;
                }
                else
                {
                    Modo = Modos.Visor;
                }
            }
        }

        private int _algoritmoSeleccionado;
        public int AlgoritmoSeleccionado
        {
            get { return _algoritmoSeleccionado; }
            set
            {
                _algoritmoSeleccionado = value;
                NotifyPropertyChanged("AlgoritmoSeleccionado");
            }
        }

        private string _contenidoBotonFichas;
        public string ContenidoBotonFichas
        {
            get { return _contenidoBotonFichas; }
            set
            {
                _contenidoBotonFichas = value;
                NotifyPropertyChanged("ContenidoBotonFichas");
            }
        }

        readonly List<string> Nombres = new List<string>{"Polyomino", "Monomino", "Domino", "Triomino", "Tetromino", 
            "Pentomino", "Hexomino", "Heptomino", "Octomino", "Nonomino", "Decomino", "Undecomino", "Dodecomino"};

        public ICommand AumentarCommand { get; private set; }
        public ICommand DisminuirCommand { get; private set; }
        public ICommand RunCommand { get; private set; }
        public ICommand GuardarCommand { get; private set; }
        public ICommand CargarCommand { get; private set; }
        public ICommand SeleccionarCasillaCommand { get; private set; }
        public ICommand AñadirFichasCommand { get; private set; }

        private Model _model;
        private ArrayList<Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>> _fichas;
        private Dictionary<char, Ficha> _fichasVisuales;
        private List<Montaje> Montajes;
        private double _filasAux, _columnasAux;


        public ViewModel(Model model)
        {
            _model = model;
            N = 5;
            Tablero = new ObservableCollection<ListaDeCasillas>();
            AumentarCommand = new RelayCommand(() => N++, () => Modo == Modos.EditarTablero);
            DisminuirCommand = new RelayCommand(() => N--, () => _n > 1 && Modo == Modos.EditarTablero);
            RunCommand = new RelayCommand(Run, () => AlgoritmoSeleccionado != 0 && Modo != Modos.EditarFichas);
            GuardarCommand = new RelayCommand(Guardar, () => Modo != Modos.Visor);
            CargarCommand = new RelayCommand(Cargar, () => true);
            SeleccionarCasillaCommand = new RelayCommand(SeleccionarCasilla, () => true);
            AñadirFichasCommand = new RelayCommand(AñadirFichas, () => true);
            _filasAux = 4;
            _columnasAux = 6;
            ContenidoSelector = new ObservableCollection<string>{"Nuevo"};
            TableroSeleccionado = 0;
            _fichasVisuales = new Dictionary<char, Ficha>();
            _fichas = new ArrayList<Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>>();
            ContenidoSelectorAlgoritmos = new ObservableCollection<string> { "Algoritmo", "Backtracking", "DLX" };
            Montajes = new List<Montaje>();
            Cargar();
            FilaSeleccionada = -1;
            ColumnaSeleccionada = -1;
            Modo = Modos.EditarTablero;
            
            //ResetDeFabrica();
        }


        private void ResetDeFabrica()
        {
            Montajes = new List<Montaje>();
            Montajes.Add(new Montaje { Nombre = "Nuevo", N = 5, Tablero = _model, Fichas = _fichas });
            CargarEjemploTetromino1();
            Montajes.Add(new Montaje { Nombre = "Ejemplo tetrominó 1", N = 4, Tablero = _model, Fichas = _fichas });
            CargarEjemploTetromino2();
            Montajes.Add(new Montaje { Nombre = "Ejemplo tetrominó 2", N = 4, Tablero = _model, Fichas = _fichas });
            GuardarADisco();
            ContenidoSelector = new ObservableCollection<string>();
            foreach (var montaje in Montajes)
            {
                ContenidoSelector.Add(montaje.Nombre);
            }
            Filas = 0;
            Filas = _filasAux;
        }

        private void AñadirFichas()
        {
            Modo = Modo == Modos.EditarTablero ? Modos.EditarFichas : Modos.EditarTablero;
        }

        private void CambiarModo()
        {
            switch (Modo)
            {
                case Modos.Visor:
                    ContenidoBotonFichas = "Fichas";
                    break;
                case Modos.EditarFichas:
                    _filasAux = Filas;
                    _columnasAux = Columnas;
                    ContenidoBotonFichas = "Tablero";
                    Filas = N;
                    Columnas = N;
                    break;
                case Modos.EditarTablero:
                    Filas = _filasAux;
                    Columnas = _columnasAux;
                    ContenidoBotonFichas = "Fichas";
                    break;
            }
            NotifyPropertyChanged("VerEditor");
            NotifyPropertyChanged("Bloqueo");
        }

        private void SeleccionarCasilla()
        {
            if (Modo == Modos.EditarFichas && _model.NumeroCasillasDeshabilitadas >= N)
            {
                return;
            }
            if (FilaSeleccionada >= 0 && FilaSeleccionada < Tablero.Count && ColumnaSeleccionada >= 0 && ColumnaSeleccionada < Tablero[FilaSeleccionada].Lista.Count)
            {
                Tablero[FilaSeleccionada].Lista[ColumnaSeleccionada].Fondo = Brushes.Black;
                _model.DeshabilitarCasilla(FilaSeleccionada, ColumnaSeleccionada);
            }
        }

        private void Run()
        {
            try
            {
                var solucion = "";
                switch (AlgoritmoSeleccionado)
                {
                    case 1:
                        var solverBacktracking = new Algoritmia.Problems.Puzzles.Polyominoes.Backtracking.PolyominoesSolver(_model.Tablero, _fichas);
                        solucion = solverBacktracking.Solve();
                        break;
                    case 2:
                        var solverDlx = new Algoritmia.Problems.Puzzles.Polyominoes.DLX.PolyominoesSolver();
                        solucion = solverDlx.Solve(_model.Tablero, _fichas);
                        break;
                }
                
                int fila = 0, columna = 0;
                foreach (var cas in solucion)
                {
                    if (cas == '\n')
                    {
                        fila++;
                        columna = 0;
                    }
                    else if (_fichasVisuales.Keys.Contains(cas))
                    {
                        _fichasVisuales[cas].Colocar(Tablero[fila].Lista[columna]);
                        columna++;
                    }
                    else
                    {
                        columna++;
                    }
                }
            }
            catch (InvalidOperationException)
            {
                MessageBox.Show("No solution found");
            }
        }

        private void RedimensionarTablero()
        {
            Tablero = new ObservableCollection<ListaDeCasillas>();
            _model = new Model();

            for (var i = 0; i < Filas; i++)
            {
                Tablero.Add(new ListaDeCasillas((int)Columnas, Brushes.Beige, 30));
                for (var j = 0; j < (int)Columnas; j++)
                {
                    _model.AñadirCasilla(i);
                }
            }
        }

        private void CargarEjemplo()
        {
            if (TableroSeleccionado == 0)
            {
                Filas = 4;
                Columnas = 6;
                _fichasVisuales = new Dictionary<char, Ficha>();
                _fichas = new ArrayList<Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>>();
            }
            else
            {
                var montaje = Montajes[TableroSeleccionado];
                _model = montaje.Tablero;
                N = montaje.N;
                _fichas = montaje.Fichas;
                Tablero = new ObservableCollection<ListaDeCasillas>();
                _fichasVisuales = new Dictionary<char, Ficha>();

                foreach (var ficha in _fichas)
                {
                    _fichasVisuales.Add(ficha.Item1, new Ficha(ficha.Item1));
                }

                for (var i = 0; i < _model.NumFilas(); i++)
                {
                    Tablero.Add(new ListaDeCasillas(_model.NumColumnas(i), Brushes.Beige, 30));
                    for (var j = 0; j < _model.NumColumnas(i); j++)
                    {
                        if (!_model.CasillaHabilitada(i, j))
                        {
                            Tablero[i].Lista[j].Fondo = Brushes.Black;
                        }
                    }
                }
            }
            
            NotifyPropertyChanged("Bloqueo");
        }

        private void Guardar()
        {
            switch (Modo)
            {
                case Modos.EditarTablero:
                    GuardarMontaje();
                    break;

                case Modos.EditarFichas:
                    GuardarFicha();
                    break;
            }
        }

        private void GuardarMontaje()
        {
            var dialogoT = new Dialogo();
            dialogoT.ShowDialog();
            if (dialogoT.Guardar && !string.IsNullOrEmpty(dialogoT.nombreTxt.Text))
            {
                var nombre = dialogoT.nombreTxt.Text;
                Montajes.Add(new Montaje { Fichas = _fichas, N = N, Nombre = nombre, Tablero = _model });
                GuardarADisco();
            }
            ContenidoSelector.Add(Montajes.Last().Nombre);
            NotifyPropertyChanged("ContenidoSelector");
        }

        private void GuardarFicha()
        {
            var dialogoF = new Dialogo();
            dialogoF.ShowDialog();
            if (dialogoF.Guardar && !string.IsNullOrEmpty(dialogoF.nombreTxt.Text))
            {
                var nombre = dialogoF.nombreTxt.Text[0];
                var contiene = false;
                var posicion = 0;
                foreach (var ficha in _fichas)
                {
                    if (ficha.Item1 == nombre)
                    {
                        contiene = true;
                        break;
                    }
                    posicion++;
                }

                var posiciones = new List<List<Tuple<int, int>>>();

                if (contiene)
                {
                    posiciones = _fichas[posicion].Item2 as List<List<Tuple<int, int>>>;
                }
                else
                {
                    _fichas.Add(new Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>(nombre, posiciones));
                    _fichasVisuales.Add(nombre, new Ficha(nombre));
                }

                posiciones.Add(new List<Tuple<int, int>>());

                for (int i = 0; i < Filas; i++)
                {
                    for (int j = 0; j < Columnas; j++)
                    {
                        if (!_model.CasillaHabilitada(i, j))
                        {
                            posiciones.Last().Add(new Tuple<int, int>(i, j));
                        }
                    }
                }
            }
            Filas = 0;
            Filas = N;
        }

        private void GuardarADisco()
        {
            Stream stream = null;
            try
            {
                IFormatter formatter = new BinaryFormatter();
                stream = new FileStream(@"data\polyominoes.dat", FileMode.Create, FileAccess.Write, FileShare.None);
                formatter.Serialize(stream, Montajes);
            }
            catch
            {
                MessageBox.Show("Fallo al volcar a disco", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                if (stream != null)
                    stream.Close();
            }
        }

        private void Cargar()
        {
            Stream stream = null;
            try
            {
                IFormatter formatter = new BinaryFormatter();
                stream = new FileStream(@"data\polyominoes.dat", FileMode.Open, FileAccess.Read, FileShare.None);
                Montajes = (List<Montaje>)formatter.Deserialize(stream);
                ContenidoSelector = new ObservableCollection<string>();
                foreach (var montaje in Montajes)
                {
                    ContenidoSelector.Add(montaje.Nombre);
                }
            }
            catch
            {
                MessageBox.Show("Fallo al cargar de disco", "Error", MessageBoxButton.OK, MessageBoxImage.Information);
            }
            finally
            {
                if (null != stream)
                    stream.Close();
            }
        }


        #region Ejemplos

        private void CargarPiezasTetromino()
        {
            _fichas = new Algoritmia.DataStructures.
                Lists.ArrayList<Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>>();
            _fichasVisuales = new Dictionary<char, Ficha>();

            //posiciones => (columna, fila)
            //I
            var posiciones = new List<List<Tuple<int, int>>>();
            //1
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[0].Add(new Tuple<int, int>(0, 0));
            posiciones[0].Add(new Tuple<int, int>(0, 1));
            posiciones[0].Add(new Tuple<int, int>(0, 2));
            posiciones[0].Add(new Tuple<int, int>(0, 3));
            //2
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[1].Add(new Tuple<int, int>(0, 0));
            posiciones[1].Add(new Tuple<int, int>(1, 0));
            posiciones[1].Add(new Tuple<int, int>(2, 0));
            posiciones[1].Add(new Tuple<int, int>(3, 0));
            _fichas.Add(new Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>('I', posiciones));
            _fichasVisuales.Add('I', new Ficha('I'));

            //O
            posiciones = new List<List<Tuple<int, int>>>();
            //1
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[0].Add(new Tuple<int, int>(0, 0));
            posiciones[0].Add(new Tuple<int, int>(1, 0));
            posiciones[0].Add(new Tuple<int, int>(0, 1));
            posiciones[0].Add(new Tuple<int, int>(1, 1));
            _fichas.Add(new Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>('O', posiciones));
            _fichasVisuales.Add('O', new Ficha('O'));

            //L
            posiciones = new List<List<Tuple<int, int>>>();
            //1
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[0].Add(new Tuple<int, int>(0, 0));
            posiciones[0].Add(new Tuple<int, int>(0, 1));
            posiciones[0].Add(new Tuple<int, int>(0, 2));
            posiciones[0].Add(new Tuple<int, int>(1, 2));
            //2
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[1].Add(new Tuple<int, int>(0, 0));
            posiciones[1].Add(new Tuple<int, int>(1, 0));
            posiciones[1].Add(new Tuple<int, int>(2, 0));
            posiciones[1].Add(new Tuple<int, int>(0, 1));
            //3
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[2].Add(new Tuple<int, int>(0, 0));
            posiciones[2].Add(new Tuple<int, int>(1, 0));
            posiciones[2].Add(new Tuple<int, int>(1, 1));
            posiciones[2].Add(new Tuple<int, int>(1, 2));
            //4
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[3].Add(new Tuple<int, int>(0, 1));
            posiciones[3].Add(new Tuple<int, int>(1, 1));
            posiciones[3].Add(new Tuple<int, int>(2, 0));
            posiciones[3].Add(new Tuple<int, int>(2, 1));
            //5
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[4].Add(new Tuple<int, int>(0, 0));
            posiciones[4].Add(new Tuple<int, int>(0, 1));
            posiciones[4].Add(new Tuple<int, int>(1, 1));
            posiciones[4].Add(new Tuple<int, int>(2, 1));
            //6
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[5].Add(new Tuple<int, int>(0, 0));
            posiciones[5].Add(new Tuple<int, int>(1, 0));
            posiciones[5].Add(new Tuple<int, int>(0, 1));
            posiciones[5].Add(new Tuple<int, int>(0, 2));
            //7
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[6].Add(new Tuple<int, int>(0, 0));
            posiciones[6].Add(new Tuple<int, int>(1, 0));
            posiciones[6].Add(new Tuple<int, int>(2, 0));
            posiciones[6].Add(new Tuple<int, int>(2, 1));
            //8
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[7].Add(new Tuple<int, int>(1, 0));
            posiciones[7].Add(new Tuple<int, int>(1, 1));
            posiciones[7].Add(new Tuple<int, int>(1, 2));
            posiciones[7].Add(new Tuple<int, int>(0, 2));
            _fichas.Add(new Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>('L', posiciones));
            _fichasVisuales.Add('L', new Ficha('L'));

            //T
            posiciones = new List<List<Tuple<int, int>>>();
            //1
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[0].Add(new Tuple<int, int>(1, 0));
            posiciones[0].Add(new Tuple<int, int>(0, 1));
            posiciones[0].Add(new Tuple<int, int>(1, 1));
            posiciones[0].Add(new Tuple<int, int>(2, 1));
            //2
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[1].Add(new Tuple<int, int>(1, 0));
            posiciones[1].Add(new Tuple<int, int>(0, 1));
            posiciones[1].Add(new Tuple<int, int>(1, 1));
            posiciones[1].Add(new Tuple<int, int>(1, 2));
            //3
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[2].Add(new Tuple<int, int>(0, 0));
            posiciones[2].Add(new Tuple<int, int>(0, 1));
            posiciones[2].Add(new Tuple<int, int>(1, 1));
            posiciones[2].Add(new Tuple<int, int>(0, 2));
            //4
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[3].Add(new Tuple<int, int>(0, 0));
            posiciones[3].Add(new Tuple<int, int>(1, 0));
            posiciones[3].Add(new Tuple<int, int>(2, 0));
            posiciones[3].Add(new Tuple<int, int>(1, 1));
            _fichas.Add(new Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>('T', posiciones));
            _fichasVisuales.Add('T', new Ficha('T'));

            //Z
            posiciones = new List<List<Tuple<int, int>>>();
            //1
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[0].Add(new Tuple<int, int>(0, 0));
            posiciones[0].Add(new Tuple<int, int>(1, 0));
            posiciones[0].Add(new Tuple<int, int>(1, 1));
            posiciones[0].Add(new Tuple<int, int>(2, 1));
            //2
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[1].Add(new Tuple<int, int>(1, 0));
            posiciones[1].Add(new Tuple<int, int>(0, 1));
            posiciones[1].Add(new Tuple<int, int>(1, 1));
            posiciones[1].Add(new Tuple<int, int>(0, 2));
            //3
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[2].Add(new Tuple<int, int>(0, 0));
            posiciones[2].Add(new Tuple<int, int>(0, 1));
            posiciones[2].Add(new Tuple<int, int>(1, 1));
            posiciones[2].Add(new Tuple<int, int>(1, 2));
            //4
            posiciones.Add(new List<Tuple<int, int>>());
            posiciones[3].Add(new Tuple<int, int>(1, 0));
            posiciones[3].Add(new Tuple<int, int>(2, 0));
            posiciones[3].Add(new Tuple<int, int>(0, 1));
            posiciones[3].Add(new Tuple<int, int>(1, 1));
            _fichas.Add(new Tuple<char, IEnumerable<IEnumerable<Tuple<int, int>>>>('Z', posiciones));
            _fichasVisuales.Add('Z', new Ficha('Z'));
        }

        private void CargarEjemploTetromino1()
        {
            CargarPiezasTetromino();
            //tablero
            //OOOOOOO
            //XOOOOOO
            //OOOOOOO
            _model = new Model();
            Tablero = new ObservableCollection<ListaDeCasillas>();
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 7; j++)
                {
                    _model.AñadirCasilla(i);
                }
                Tablero.Add(new ListaDeCasillas(7, Brushes.Beige, 30));
            }
            _model.DeshabilitarCasilla(1,0);
            Tablero[1].Lista[0].Fondo = Brushes.Black;

            N = 4;
        }

        private void CargarEjemploTetromino2()
        {
            CargarPiezasTetromino();
            //tablero
            //OOOOOX
            //OOOOOO
            //OOOXXX
            //OOOOOO
            _model = new Model();
            Tablero = new ObservableCollection<ListaDeCasillas>();
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 6; j++)
                {
                    _model.AñadirCasilla(i);
                }
                Tablero.Add(new ListaDeCasillas(10, Brushes.Beige, 30));
            }
            _model.DeshabilitarCasilla(0, 5);
            _model.DeshabilitarCasilla(2, 3);
            _model.DeshabilitarCasilla(2, 4);
            _model.DeshabilitarCasilla(2, 5);
            Tablero[0].Lista[5].Fondo = Brushes.Black;
            Tablero[2].Lista[3].Fondo = Brushes.Black;
            Tablero[2].Lista[4].Fondo = Brushes.Black;
            Tablero[2].Lista[5].Fondo = Brushes.Black;

            N = 4;
        }

        #endregion
    }
}
